﻿using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Navigation;
using LASGui.Classes;
using LASGui.MainService;

namespace LASGui.Views
{
    public partial class Asientos
    {
        private readonly List<String> _accountsNameList = new List<string>();
        private readonly List<Account> _accountsList = new List<Account>();
        private readonly AuthenticatedUser _authenticatedUserManager = AuthenticatedUser.Instance;
        private ObservableCollection<IEntry> _transactionCollection = new ObservableCollection<IEntry>();
        private ObservableCollection<String> _currencyList = new ObservableCollection<String>();
        private ObservableCollection<VisualEntry> _entryCollection = new ObservableCollection<VisualEntry>();
        private CustomChildWindow _dialog;
        private double _localExchange;
        private double _otherExchange;
        private int _otherCurrencyId;
        
        #region Navegacion
        /// <summary>
        /// Evento de navegacion que se dispara al terminar la navegación a esta página.
        /// </summary>
        /// <param name="e"></param>
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            if (_authenticatedUserManager.OnlineUser == null)
            {
                LogOff();
            }

            foreach (var currency in _authenticatedUserManager.CompanyCurrency)
            {
                _currencyList.Add(currency.CurrencyName);
            }

            InitializeComponent();
            GridAsientosAgregar.ItemsSource = _transactionCollection;
            LoadAccounts();
            InputTransaccionCuenta.ItemsSource = _accountsNameList;
            InputTransaccionCuenta.SelectionChanged += InputTransaccionCuentaSelectionChanged;
            InputTransaccionCuenta.SelectedIndex = 0;
            InputTransaccionMoneda.ItemsSource = _currencyList;
            GridAsientosDetalles.ItemsSource = _entryCollection;
            CrearUltimaFila();            
        }

        /// <summary>
        /// Método que obliga al usuario a salir de su sesión si se presenta un error de conexión o si intenta accesar a un zona reestringida sin haberse autenticado primero.
        /// </summary>
        public void LogOff()
        {
            _authenticatedUserManager.OnlineUser = null;
            NavigationService.Navigate(new Uri("/Home", UriKind.Relative));
            var mainPage = ((App)Application.Current).Mainpage;
            mainPage.HideMainMenu();

        }
        #endregion

        #region Operaciones del grid
        /// <summary>
        /// Crea la fila del total de los asientos en el grid
        /// </summary>
        private void CrearUltimaFila()
        {
            double sumaSistemaHaber = 0;
            double sumaSistemaDebe = 0;
            double sumaLocalHaber = 0;
            double sumaLocalDebe = 0;


            foreach (var entry in _transactionCollection)
            {
                if (!string.IsNullOrEmpty(entry.SistemaHaberInit)) sumaSistemaHaber += double.Parse(entry.SistemaHaberInit);
                if (!string.IsNullOrEmpty(entry.SistemaDebeInit)) sumaSistemaDebe += double.Parse(entry.SistemaDebeInit);
                if (!string.IsNullOrEmpty(entry.SistemaHaberInit)) sumaLocalHaber += double.Parse(entry.LocalHaberInit);
                if (!string.IsNullOrEmpty(entry.LocalDebeInit)) sumaLocalDebe += double.Parse(entry.LocalDebeInit);

            }

            var total = new SystemEntry(1)
                            {
                                SistemaHaberInit = sumaSistemaHaber.ToString(),
                                SistemaDebeInit = sumaSistemaDebe.ToString(),
                                LocalHaberInit = sumaLocalHaber.ToString(),
                                LocalDebeInit = sumaLocalDebe.ToString(),
                                NombreCuenta = "TOTAL"
                            };

            _transactionCollection.Add(total);
        }

        /// <summary>
        /// Actualiza la transaccion en la interfaz y en el objeto de referencia
        /// </summary>
        /// <param name="tipoMoneda"></param>
        public void SetTransaction(int tipoMoneda)
        {
            {

                IEntry nuevaTransaccion = null;
                var tipoTransaccion = InputTransaccionTipo.SelectedIndex + 1;
                var sistema = "";
                var local = "";
                var otra = "";
                var tipoCambio = "";
                Double sistemaValor;

                //Elije la moneda adecuada
                switch (tipoMoneda)
                {
                    case 0:
                        nuevaTransaccion = new SystemEntry(tipoTransaccion);
                        sistemaValor = double.Parse(InputTransaccionMonto.Text);
                        sistema = sistemaValor.ToString("0.0000");
                        local = (sistemaValor * _localExchange).ToString("0.0000");
                        otra = "";
                        tipoCambio = "";
                        break;
                    case 1:
                        sistemaValor = double.Parse(InputTransaccionMonto.Text) / _localExchange;
                        nuevaTransaccion = new LocalEntry(InputTransaccionTipo.SelectedIndex + 1);
                        sistema = sistemaValor.ToString("0.0000");
                        local = InputTransaccionMonto.Text;
                        otra = "";
                        tipoCambio = "";
                        break;
                    case 2:
                        sistemaValor = double.Parse(InputTransaccionMonto.Text) / _otherExchange;
                        nuevaTransaccion = new OtherEntry(InputTransaccionTipo.SelectedIndex + 1);
                        sistema = sistemaValor.ToString();
                        local = (sistemaValor * _localExchange).ToString("0.0000");
                        otra = InputTransaccionMonto.Text;
                        tipoCambio = _otherExchange.ToString();
                        break;
                }

                nuevaTransaccion.NombreCuenta = (String)InputTransaccionCuenta.SelectedValue;

                if (_transactionCollection.Count > 0) _transactionCollection.RemoveAt(_transactionCollection.Count - 1);

                if (tipoTransaccion == 1)
                {
                    nuevaTransaccion.InitDebe(local, sistema, otra, tipoCambio, (String)InputTransaccionMoneda.SelectedItem, _localExchange.ToString());
                    var arrayForCopy = new IEntry[_transactionCollection.Count];
                    _transactionCollection.CopyTo(arrayForCopy, 0);
                    _transactionCollection.Clear();
                    _transactionCollection.Add(nuevaTransaccion);
                    foreach (var entry in arrayForCopy)
                    {
                        _transactionCollection.Add(entry);
                    }
                }
                else
                {
                    nuevaTransaccion.InitHaber(local, sistema, otra, tipoCambio, (String)InputTransaccionMoneda.SelectedItem, _localExchange.ToString());
                    _transactionCollection.Add(nuevaTransaccion);
                }

                CrearUltimaFila();

                //Se crea el asiento de referencia
                if (string.IsNullOrEmpty(tipoCambio)) tipoCambio += "0";
                if (string.IsNullOrEmpty(otra)) otra += "0";

                var otroMonto = double.Parse(otra);
                var localMonto = double.Parse(local);
                var sistemaMonto = double.Parse(sistema);
                
                if ((String)(InputTransaccionTipo.SelectedValue as Label).Content=="Haber")
                {
                    otroMonto = otroMonto*-1;
                    localMonto = localMonto*-1;
                    sistemaMonto = sistemaMonto*-1;
                }

                var asientoReferencia = new EntryHasAccount()
                {
                    AccountId = _accountsList[InputTransaccionCuenta.SelectedIndex].AccountId,
                    ExchangeRate = new Decimal(double.Parse(tipoCambio)),
                    ForeignBalance = new Decimal(otroMonto),
                    LocalBalance = new Decimal(localMonto),
                    TransactionType = (String)(InputTransaccionTipo.SelectedValue as Label).Content,
                    SystemBalance = new Decimal(sistemaMonto)
                };

                nuevaTransaccion.AsientoReferencia = asientoReferencia;

                //Habilita y limpia para un nueva transaccion
                InputTransaccionCuenta.SelectedIndex = 0;
                InputTransaccionMonto.Text = "";
                InputTransaccionTipo.SelectedIndex = 0;

                InputTransaccionCuenta.IsEnabled = true;
                InputTransaccionMoneda.IsEnabled = true;
                InputTransaccionMonto.IsEnabled = true;
                InputTransaccionTipo.IsEnabled = true;
            }
        }
        #endregion
        
        #region Operaciones del arbol de cuentas
        /// <summary>
        /// Método que crea el árbol y agrega las hojas al combo
        /// </summary>
        /// <param name="toBeParent">Cuenta que será desglosada para determinar los hijos y los hijos de los hijos</param>
        public void LoadAccountChildTree(Account toBeParent)
        {

            if (toBeParent.Children.Count == 0)
            {
                _accountsNameList.Add(toBeParent.AccountCode + " " + toBeParent.AccountName);
                _accountsList.Add(toBeParent);
                return;
            }

            foreach (var child in toBeParent.Children)
            {
                LoadAccountChildTree(child);
            }
        }

        /// <summary>
        /// Método que crea el árbol de una de las cuentas título dentro de el catálogo de cuentas.
        /// </summary>
        public void LoadAccounts()
        {

            for (int cuentaTitulo = 0; cuentaTitulo < 8; cuentaTitulo++)
            {
                var tituloActual = _authenticatedUserManager.OnlineUser.Company.AccountCatalog.Accounts[cuentaTitulo];

                LoadAccountChildTree(tituloActual);
            }
        }
        #endregion

        #region Webservice calls

        /// <summary>
        /// Metodo que verifica si el tipo de cambio local-sistema ya fue definido para la fecha elegida
        /// </summary>
        public void VerifyLocalSystemExchangeRateExist()
        {
            var client = new MainServiceSilverlightClient();
            var usuario = _authenticatedUserManager.OnlineUser;
            client.GetExchangeRateCompleted += ClientGetLocalSystemExchangeRateCompleted;
            client.GetExchangeRateAsync(usuario.CompanyId, usuario.Company.SystemCurrency.CurrencyId, usuario.Company.LocalCurrency.CurrencyId, (DateTime)InputEntryDate.SelectedDate);
        }

        /// <summary>
        /// Metodo que inserta el nuevo tipo de cambio local-sistema
        /// </summary>
        public void InsertLocalSystemExchangeRate(DateTime fechaInicio, DateTime fechaFinal, double monto)
        {
            var client = new MainServiceSilverlightClient();
            var usuario = _authenticatedUserManager.OnlineUser;
            client.InsertExchangeRateCompleted += ClientInsertLocalSystemExchangeRateCompleted;
            client.InsertExchangeRateAsync(usuario.CompanyId, usuario.Company.SystemCurrency.CurrencyId,
                                           usuario.Company.LocalCurrency.CurrencyId, fechaInicio, fechaFinal, new Decimal(monto));
        }

        /// <summary>
        /// Metodo que verifica si el tipo de cambio otro-sistema ya fue definido para la fecha elegida
        /// </summary>
        public void VerifyOtherSystemExchangeRateExist()
        {
            var client = new MainServiceSilverlightClient();
            var usuario = _authenticatedUserManager.OnlineUser;
            client.GetExchangeRateCompleted += ClientGetOtherSystemExchangeRateCompleted;
            client.GetExchangeRateAsync(usuario.CompanyId, usuario.Company.SystemCurrency.CurrencyId, _otherCurrencyId, (DateTime)InputEntryDate.SelectedDate);
        }

        /// <summary>
        /// Metodo que inserta el nuevo tipo de cambio otro-sistema
        /// </summary>
        /// <param name="fechaInicio"></param>
        /// <param name="fechaFinal"></param>
        /// <param name="monto"></param>
        public void InsertOtherSystemExchangeRate(DateTime fechaInicio, DateTime fechaFinal, double monto)
        {
            var client = new MainServiceSilverlightClient();
            var usuario = _authenticatedUserManager.OnlineUser;
            client.InsertExchangeRateCompleted += ClientInsertOtherSystemExchangeRateCompleted;
            client.InsertExchangeRateAsync(usuario.CompanyId, usuario.Company.SystemCurrency.CurrencyId,
                                           _otherCurrencyId, fechaInicio, fechaFinal, new Decimal(monto));
        }

        /// <summary>
        /// Inicia el proceso de transaccion acorde al tipo de moneda
        /// </summary>
        public void GetCurrenctType()
        {
            var idMonedaTransaccion = 0;

            foreach (var moneda in _authenticatedUserManager.CompanyCurrency.Where(moneda => moneda.CurrencyName == (String)InputTransaccionMoneda.SelectedItem))
            {
                idMonedaTransaccion = moneda.CurrencyId;
            }

            if (idMonedaTransaccion == _authenticatedUserManager.OnlineUser.Company.SystemCurrency.CurrencyId)
            {
                SetTransaction(0);
            }
            else if (idMonedaTransaccion == _authenticatedUserManager.OnlineUser.Company.LocalCurrency.CurrencyId)
            {
                SetTransaction(1);
            }
            else
            {
                _otherCurrencyId = idMonedaTransaccion;
                VerifyOtherSystemExchangeRateExist();
            }
        }

        
        /// <summary>
        /// Obtiene los asientos anteriores segun un determinado rango de fechas
        /// </summary>
        /// <param name="inicio"></param>
        /// <param name="final"></param>
        public void LoadEntries(DateTime inicio, DateTime final)
        {
            var client = new MainServiceSilverlightClient();
            client.GetEntriesFromCompanyCompleted += ClientGetEntriesFromCompanyCompleted;
            client.GetEntriesFromCompanyAsync(_authenticatedUserManager.OnlineUser.Company.CompanyId,inicio, final);
        }

        /// <summary>
        /// Elimina un asiento del sistema
        /// </summary>
        /// <param name="id"></param>
        public void DeleteEntry(int id)
        {
            var client = new MainServiceSilverlightClient();
            client.EraseEntryCompleted += ClientEraseEntryCompleted;
            client.EraseEntryAsync(id);            
        }


        /// <summary>
        /// Agrega un asiento del sistema
        /// </summary>
        /// <param name="nuevoAsiento"></param>
        public void AddEntry(Entry nuevoAsiento)
        {
            var client = new MainServiceSilverlightClient();
            client.InsertEntryCompleted += ClientInsertEntryCompleted;
            client.InsertEntryAsync(nuevoAsiento);
        }
         
        #endregion

        #region Mouse Events
        /// <summary>
        /// Se agrega la nueva transacción.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void AgregarTransaccion(object sender, RoutedEventArgs e)
        {
            //Pregunta si la fecha ya fue elegida
            if (InputEntryDate.SelectedDate == null)
            {
                //Si la fecha no ha sido elegida le obliga a escoger una y le da disable al componente de fecha
                var errorFecha = new CustomChildWindow(Constants.ASIENTOS_ERROR_TRANSACCION,
                                                       Constants.ASIENTOS_ERROR_TRANSACCION_DATE);
                errorFecha.Show();
                return;
            }
            if (InputTransaccionMoneda.SelectedItem == null)
            {
                var errorFecha = new CustomChildWindow(Constants.ASIENTOS_ERROR_TRANSACCION,
                                                       Constants.ASIENTOS_ERROR_TRANSACCION_MONEDA);
                errorFecha.Show();
                return;
            }
            if (String.IsNullOrEmpty(InputTransaccionMonto.Text))
            {
                var errorFecha = new CustomChildWindow(Constants.ASIENTOS_ERROR_TRANSACCION,
                                                       Constants.ASIENTOS_ERROR_TRANSACCION_MONTO);
                errorFecha.Show();
                return;
            }

            InputEntryDate.IsEnabled = false;
            InputTransaccionCuenta.IsEnabled = false;
            InputTransaccionMoneda.IsEnabled = false;
            InputTransaccionMonto.IsEnabled = false;
            InputTransaccionTipo.IsEnabled = false;
            VerifyLocalSystemExchangeRateExist();
        }

        /// <summary>
        /// Metodo que actualiza los detalles de los asientos segun el rango ingresado
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void ActualizarDetalleAsientos(object sender, RoutedEventArgs e)
        {
            if (ValidationData.DateValidation(InputEntriesDetailInit, InputEntriesDetailEnd))
            {
                LoadEntries((DateTime)InputEntriesDetailInit.SelectedDate, (DateTime)InputEntriesDetailEnd.SelectedDate);

            }
            else
            {
                var dialog = new CustomChildWindow(Constants.ASIENTOS_ERROR_DETALLES, Constants.ASIENTOS_ERROR_DETALLES_FECHAS);
                dialog.Show();
            }
        }

        /// <summary>
        /// Método que agrega un nuevo asiento
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void AgregarAsiento(object sender, RoutedEventArgs e)
        {
            if(_transactionCollection.Count==1)
            {
                var dialog = new CustomChildWindow(Constants.ASIENTOS_ERROR_CREAR, Constants.ASIENTOS_ERROR_CREAR_NOTRAN);
                dialog.Show();
                return;
            }

            if (double.Parse(_transactionCollection[_transactionCollection.Count - 1].SistemaDebe) != double.Parse(_transactionCollection[_transactionCollection.Count - 1].SistemaHaber))
            {
                var dialog = new CustomChildWindow(Constants.ASIENTOS_ERROR_CREAR, Constants.ASIENTOS_ERROR_CREAR_NOCIERRA);
                dialog.Show();
                return;
            }

            var cuentasDebe = new ObservableCollection<EntryHasAccount>();
            var cuentasHaber = new ObservableCollection<EntryHasAccount>();

            _transactionCollection.RemoveAt(_transactionCollection.Count-1);

            foreach (var entradaGrid in _transactionCollection)
            {
                if (entradaGrid.AsientoReferencia.TransactionType=="Debe")
                {
                    cuentasDebe.Add(entradaGrid.AsientoReferencia);
                }
                else
                {
                    cuentasHaber.Add(entradaGrid.AsientoReferencia);
                }
                
            }

            var nuevoAsiento = new Entry()
                                   {
                                       UserId = _authenticatedUserManager.OnlineUser.UserId,
                                       Comentario = InputEntryComment.Text,
                                       CompanyId = _authenticatedUserManager.OnlineUser.CompanyId,
                                       CreditAccounts = cuentasHaber,
                                       DebitAccounts = cuentasDebe,
                                       DocumentDate = (DateTime)InputEntryDate.SelectedDate,
                                       EntryType = "AS",
                                       Reference1 = InputEntryRef1.Text,
                                       Reference2 = InputEntryRef2.Text,
                                       Reference3 = InputEntryRef3.Text
                                   };
           
            InputEntryComment.IsEnabled = false;
            InputEntryRef1.IsEnabled = false;
            InputEntryRef2.IsEnabled = false;
            InputEntryRef3.IsEnabled = false;
            
            AddEntry(nuevoAsiento);
        } 

        #endregion

        #region Selection Events
        /// <summary>
        /// Evento que se dispara al cambiar de cuenta
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void InputTransaccionCuentaSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            _currencyList.Clear();

            var currentCurrency = _accountsList[InputTransaccionCuenta.SelectedIndex].Currency;

            if (currentCurrency.CurrencyId == 1)
            {
                foreach (var currency in _authenticatedUserManager.CompanyCurrency)
                {
                    _currencyList.Add(currency.CurrencyName);
                }

                _currencyList.RemoveAt(0);
            }
            else
            {
                _currencyList.Add(currentCurrency.CurrencyName);
            }
        }
        #endregion

        #region Keyboard Events
        /// <summary>
        /// Método que se dipara al presionar la tecla para modificar la tabla.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e">La tecla delete</param>
        private void GridAsientosAgregarKeyDown(object sender, KeyEventArgs e)
        {
            if (Key.Delete == e.Key && null != GridAsientosAgregar.SelectedItem)
            {
                if (GridAsientosAgregar.SelectedIndex == (_transactionCollection.Count - 1) && _transactionCollection.Count == 1)
                {
                    return;
                }
                if (GridAsientosAgregar.SelectedIndex == 0 && _transactionCollection.Count == 2)
                {
                    _transactionCollection.Remove(GridAsientosAgregar.SelectedItem as IEntry);
                    InputEntryDate.IsEnabled = true;
                    _transactionCollection.Clear();
                    CrearUltimaFila();
                }

                _transactionCollection.Remove(GridAsientosAgregar.SelectedItem as IEntry);
                _transactionCollection.RemoveAt(_transactionCollection.Count - 1);
                CrearUltimaFila();
            }
            if(Key.Delete == e.Key && null != GridAsientosDetalles.SelectedItem)
            {
                if((GridAsientosDetalles.SelectedItem as VisualEntry).Tipo==1)
                {
                    DeleteEntry((GridAsientosDetalles.SelectedItem as VisualEntry).Id);
                }
            }
        }
        #endregion

        #region Webservice completeness events for asynchronous calls

        /// <summary>
        /// Evento para la llamada de obtener el tipo de cambio de la moneda del sistema y la moneda local
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void ClientGetLocalSystemExchangeRateCompleted(object sender, GetExchangeRateCompletedEventArgs e)
        {
            System.Globalization.NumberFormatInfo ni = null;
            System.Globalization.CultureInfo ci = System.Globalization.CultureInfo.InvariantCulture;
            ni = (System.Globalization.NumberFormatInfo)ci.NumberFormat.Clone();
            ni.NumberDecimalSeparator = ".";
            try
            {
                if (e.Error != null)
                {
                    ChildWindow errorWindow = new CustomChildWindow(e.Error);
                    errorWindow.Show();
                }
                if (e.Result == 0)
                {
                    ChildWindow errorWindow = new CustomChildWindow(Constants.ASIENTOS_ERROR_CREAR,"");
                    errorWindow.Show();
                }
                else
                {
                    _localExchange = Convert.ToDouble(e.Result, System.Globalization.CultureInfo.InvariantCulture);


                    if (e.Result == 1)
                    {
                        _dialog = new CustomChildWindow(Constants.ASIENTOS_DIALOGO_MONTO_LS, Constants.ASIENTOS_DIALOGO_FECHA, 1, (DateTime)InputEntryDate.SelectedDate);
                        _dialog.OkClicked += DialogOkClicked;
                        _dialog.Show();
                    }
                    else
                    {
                        GetCurrenctType();
                    }
                }
            }
            catch (Exception ex)
            {
                var dialog = new CustomChildWindow(ex.Message);
                dialog.Show();
            }
        }

        /// <summary>
        /// Evento para la llamada insertar el tipo de cambio de la moneda del sistema y la moneda local
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void ClientInsertLocalSystemExchangeRateCompleted(object sender, InsertExchangeRateCompletedEventArgs e)
        {
            try
            {
                if (e.Error != null)
                {
                    ChildWindow errorWindow = new CustomChildWindow(e.Error);
                    errorWindow.Show();
                }
                else
                {
                    GetCurrenctType();
                }
            }
            catch (Exception ex)
            {
                var dialog = new CustomChildWindow(ex.Message);
                dialog.Show();
            }
        }

        /// <summary>
        /// Evento para la llamada de obtener el tipo de cambio de la moneda del sistema y la extranjera
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void ClientGetOtherSystemExchangeRateCompleted(object sender, GetExchangeRateCompletedEventArgs e)
        {
            try
            {
                if (e.Error != null)
                {
                    ChildWindow errorWindow = new CustomChildWindow(e.Error);
                    errorWindow.Show();
                }
                if (e.Result == 0)
                {
                    ChildWindow errorWindow = new CustomChildWindow(Constants.ASIENTOS_ERROR_CREAR, "");
                    errorWindow.Show();
                }
                else
                {
                    _otherExchange = Convert.ToDouble(e.Result, System.Globalization.CultureInfo.InvariantCulture);

                    if (e.Result == 1)
                    {
                        _dialog = new CustomChildWindow(Constants.ASIENTOS_DIALOGO_MONTO_OS, Constants.ASIENTOS_DIALOGO_FECHA, 2, (DateTime)InputEntryDate.SelectedDate);
                        _dialog.OkClicked += DialogOkClicked;
                        _dialog.Show();
                    }
                    else
                    {
                        SetTransaction(2);
                    }
                }
            }
            catch (Exception ex)
            {
                var dialog = new CustomChildWindow(ex.Message);
                dialog.Show();
            }
        }

        public void ClientInsertOtherSystemExchangeRateCompleted(object sender, InsertExchangeRateCompletedEventArgs e)
        {
            try
            {
                if (e.Error != null)
                {
                    //ChildWindow errorWindow = new CustomChildWindow(e.Error);
                    //errorWindow.Show();

                    ChildWindow errorWindow = new CustomChildWindow(Constants.ASIENTOS_ERROR_TRANSACCION, Constants.ASIENTOS_ERROR_TRANSACCION_TIPOCAMBIO);
                    errorWindow.Show();
                }
                else
                {
                    SetTransaction(2);
                }
            }
            catch (Exception ex)
            {
                var dialog = new CustomChildWindow(ex.Message);
                dialog.Show();
            }
        }

        /// <summary>
        /// Evento para la llamada de cargar los asientos anteriores
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void ClientGetEntriesFromCompanyCompleted(object sender, GetEntriesFromCompanyCompletedEventArgs e)
        {
            try
            {
                if (e.Error != null)
                {
                    //ChildWindow errorWindow = new CustomChildWindow(e.Error);
                    //errorWindow.Show();

                    ChildWindow errorWindow = new CustomChildWindow(Constants.ASIENTOS_ERROR_DETALLES, Constants.ERROR_CONEXION);
                    errorWindow.Show();
                }
                if (e.Result == null || e.Result.Count == 0)
                {
                    //ChildWindow errorWindow = new CustomChildWindow(e.Error);
                    //errorWindow.Show();

                    ChildWindow errorWindow = new CustomChildWindow(Constants.ASIENTOS_DETALLES_NOTIFICACION, "");
                    errorWindow.Show();
                    _entryCollection.Clear();
                }
                else
                {
                    _entryCollection.Clear();
                    
                    //Agrega el asiento
                    foreach (var asiento in e.Result)
                    {
                        //Agrega el encabezado
                        var visualEntryGeneral = new VisualEntry()
                                              {
                                                  Comentario = asiento.Comentario,
                                                  Fecha = asiento.DocumentDate.ToString(),
                                                  Referencia1 = asiento.Reference1,
                                                  Referencia2 = asiento.Reference2,
                                                  Referencia3 = asiento.Reference3,
                                                  Tipo = 1,
                                                  Id = asiento.EntryId,
                                                  IdUnico = asiento.UniqueEntryId.ToString()
                                              };

                        _entryCollection.Add(visualEntryGeneral);


                        //Agrega las transacciones del debe
                        foreach (var transaccionDebe in asiento.DebitAccounts)
                        {
                            var nombreCuenta = "";
                            
                            foreach (var cuenta in _accountsList.Where(cuenta => cuenta.AccountId == transaccionDebe.AccountId))
                            {
                                nombreCuenta = cuenta.AccountName;
                            }
                            
                            var visualEntryDebe = new VisualEntry()
                                                          {
                                                              LocalDebe = transaccionDebe.LocalBalance.ToString(),
                                                              SistemaDebe = transaccionDebe.SystemBalance.ToString(),
                                                              NombreCuenta = nombreCuenta,
                                                              OtraDebe = transaccionDebe.ForeignBalance.ToString(),
                                                              TipoCambio = transaccionDebe.ExchangeRate.ToString(),
                                                              Tipo = 2
                                                          };
                            _entryCollection.Add(visualEntryDebe);
                        }

                        
                        //Agrega las transacciones del haber
                        foreach (var transaccionHaber in asiento.CreditAccounts)
                        {
                            var nombreCuenta = "";

                            foreach (var cuenta in _accountsList.Where(cuenta => cuenta.AccountId == transaccionHaber.AccountId))
                            {
                                nombreCuenta = cuenta.AccountName;
                            }

                            var visualEntryDebe = new VisualEntry()
                            {
                                LocalHaber = (transaccionHaber.LocalBalance * -1).ToString(),
                                SistemaHaber =  (transaccionHaber.SystemBalance * -1).ToString(),
                                NombreCuenta = "\t" + nombreCuenta,
                                OtraHaber = (transaccionHaber.ForeignBalance*-1).ToString(),
                                TipoCambio = transaccionHaber.ExchangeRate.ToString(),
                                Tipo = 2
                            };
                            _entryCollection.Add(visualEntryDebe);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                var dialog = new CustomChildWindow(ex.Message);
                dialog.Show();
            }
        }


        /// <summary>
        /// Evento para la llamada de borrar un asiento
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void ClientEraseEntryCompleted(object sender, EraseEntryCompletedEventArgs e)
        {
                try
                {
                    if (e.Error != null)
                    {
                        //ChildWindow errorWindow = new CustomChildWindow(e.Error);
                        //errorWindow.Show();

                        ChildWindow errorWindow = new CustomChildWindow(Constants.ASIENTOS_ERROR_DETALLES, Constants.ERROR_CONEXION);
                        errorWindow.Show();
                    }
                    else
                    {
                        LoadEntries((DateTime)InputEntriesDetailInit.SelectedDate, (DateTime)InputEntriesDetailEnd.SelectedDate);
                    }
                }
                catch (Exception ex)
            {
                var dialog = new CustomChildWindow(ex.Message);
                dialog.Show();
            }
        }

        public void ClientInsertEntryCompleted(object sender, InsertEntryCompletedEventArgs e)
        {
            try
            {
                if (e.Error != null)
                {
                    //ChildWindow errorWindow = new CustomChildWindow(e.Error);
                    //errorWindow.Show();

                    ChildWindow errorWindow = new CustomChildWindow(Constants.ASIENTOS_ERROR_CREAR, Constants.ERROR_CONEXION);
                    errorWindow.Show();
                }
                if(e.Result==false)
                {
                    ChildWindow errorWindow = new CustomChildWindow(Constants.ASIENTOS_ERROR_CREAR, Constants.ERROR_CONEXION);
                    errorWindow.Show();
                }
                else
                {
                    _transactionCollection.Clear();
                    CrearUltimaFila();
                    InputEntryComment.Text = "";
                    InputEntryRef1.Text = "";
                    InputEntryRef2.Text = "";
                    InputEntryRef3.Text = "";

                    InputEntryComment.IsEnabled = true;
                    InputEntryRef1.IsEnabled = true;
                    InputEntryRef2.IsEnabled = true;
                    InputEntryRef3.IsEnabled = true;
                    InputEntryDate.IsEnabled = true;

                    ChildWindow errorWindow = new CustomChildWindow("", Constants.ASIENTOS_EXITO_CREAR);
                    errorWindow.Show();

                }
            }
            catch (Exception ex)
            {
                var dialog = new CustomChildWindow(ex.Message);
                dialog.Show();
            }
        }
        #endregion

        #region Dialog Events
        public void DialogOkClicked(object sender, EventArgs e)
        {
            switch (_dialog.Estado)
            {
                case 1:
                    if (!String.IsNullOrEmpty(_dialog.Monto.Text) && ValidationData.IsNaturalNumber(_dialog.Monto.Text))
                    {
                        _dialog.MontoTipoCambio = double.Parse(_dialog.Monto.Text);
                        _dialog.PanelMonto.Visibility = Visibility.Collapsed;
                        _dialog.PanelRango.Visibility = Visibility.Visible;
                        _dialog.ErrorTextBox.Text = _dialog.OtroMensaje;
                        _dialog.Estado++;
                    }
                    break;
                case 2:
                    if (ValidationData.DateValidation(_dialog.FechaInicio, _dialog.FechaFinal, _dialog.FechaIntermedio))
                    {
                        switch (_dialog.Tipo)
                        {
                            case 1:
                                InsertLocalSystemExchangeRate((DateTime)_dialog.FechaInicio.SelectedDate, (DateTime)_dialog.FechaFinal.SelectedDate, double.Parse(_dialog.Monto.Text));
                                _localExchange = double.Parse(_dialog.Monto.Text);
                                break;
                            case 2:
                                InsertOtherSystemExchangeRate((DateTime)_dialog.FechaInicio.SelectedDate, (DateTime)_dialog.FechaFinal.SelectedDate, double.Parse(_dialog.Monto.Text));
                                _otherExchange = double.Parse(_dialog.Monto.Text);
                                break;
                        }
                        _dialog.DialogResult = true;
                    }
                    break;
                default:
                    _dialog.DialogResult = true;
                    break;
            }
        }

        
        #endregion
    }


}